{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "from numpy import *\n",
    "import operator\n",
    "from os import listdir\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def createDataSet():\n",
    "#     1.每年获得的飞行常客里程数\n",
    "#     2.玩视频游戏占用的时间百分比\n",
    "#     3.每周消耗的冰淇淋公升数\n",
    "    group = array([[1.0,1.1],[1.0,1.0],[0,0],[0,0.1]])\n",
    "    labels = ['A','A','B','B']\n",
    "    return group, labels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1.0, 1.0]"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "group, labels=createDataSet()\n",
    "ax=[]\n",
    "ay=[]\n",
    "bx=[]\n",
    "by=[]\n",
    "for i in range(len(labels)):\n",
    "    if labels[i]=='A':\n",
    "        ax.append(group[i][0])\n",
    "        ay.append(group[i][1])\n",
    "    else:\n",
    "        bx.append(group[i][0])\n",
    "        by.append(group[i][1])\n",
    "ax"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = plt.figure()\n",
    "ax1 = fig.add_subplot(111)\n",
    "ax1.scatter(ax, ay, s=30, c='red', marker='s')       #散点图  \n",
    "ax1.scatter(bx, by, s=30, c='green')\n",
    "\n",
    "# 直线 x 的范围\n",
    "\n",
    "# 画出直线，weights[0]*1.0+weights[1]*x+weights[2]*y=0  \n",
    "# 之前计算时对原始数据做了拓展，将两维拓展为三维，第一维全部设置为1.0，实际他是一个 y=ax+b, b常量  \n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def classify0(inX, dataSet, labels, k):\n",
    "    \"\"\"\n",
    "    用于分类的输入向量：inX\n",
    "    输入训练集：dataSet\n",
    "    标签向量：labels\n",
    "    选择近邻的数目：k\n",
    "    \"\"\"\n",
    "    #标签向量的元素和矩阵dataSet的行数相同，dataSetSize为行数\n",
    "    dataSetSize = dataSet.shape[0]\n",
    "    #将inX向量按行重复dataSetSize次，列重复一次，变成与dataSet一样的形式，并计算差值diffMat\n",
    "    diffMat = tile(inX, (dataSetSize,1)) - dataSet\n",
    "    print(diffMat)\n",
    "    #对差值求平方\n",
    "    sqDiffMat = diffMat**2\n",
    "    print(sqDiffMat)\n",
    "    #axis=1 把每一行向量的值加在一起求和\n",
    "    sqDistances = sqDiffMat.sum(axis=1)\n",
    "    distances = sqDistances**0.5\n",
    "    print('distances:',distances)\n",
    "    #argsort():将x中的元素从小到大排列，提取其对应的index(索引)，然后输出索引\n",
    "    sortedDistIndicies = distances.argsort()\n",
    "    print('sortedDistIndicies',sortedDistIndicies)\n",
    "    classCount={}\n",
    "    for i in range(k):\n",
    "        #sortedDistIndicies[i]返回的是distances中排在第i个数值的索引\n",
    "        #labels[i]:即返回的是第i个位置的向量的标签存入voteIlabel\n",
    "        voteIlabel = labels[sortedDistIndicies[i]]\n",
    "        #更新字典中对应标签的数值\n",
    "        classCount[voteIlabel] = classCount.get(voteIlabel,0) + 1\n",
    "    \"\"\"\n",
    "    sorted(itera ble[, cmp[, key[, reverse]]])\n",
    "    参数解释：\n",
    "（1）iterable指定要排序的list或者iterable，不用多说；\n",
    "（2）cmp为函数，指定排序时进行比较的函数，可以指定一个函数或者lambda函数，如：\n",
    "      students为类对象的list，每个成员有三个域，用sorted进行比较时可以自己定cmp函数，例如这里要通过比较第三个数据成员来排序，代码可以这样写：\n",
    "      students = [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]\n",
    "      sorted(students, key=lambda student : student[2])\n",
    "（3）key为函数，指定取待排序元素的哪一项进行排序，函数用上面的例子来说明，代码如下：\n",
    "       sorted(students, key=lambda student : student[2]) \n",
    "       key指定的lambda函数功能是去元素student的第三个域（即：student[2]），因此sorted排序时，会以students所有元素的第三个域来进行排序。\n",
    "有了上面的operator.itemgetter函数，也可以用该函数来实现，例如要通过student的第三个域排序，可以这么写：\n",
    "sorted(students, key=operator.itemgetter(2)) \n",
    "sorted函数也可以进行多级排序，例如要根据第二个域和第三个域进行排序，可以这么写：\n",
    "sorted(students, key=operator.itemgetter(1,2))  \n",
    "    \"\"\"\n",
    "    print(classCount)\n",
    "    #{'A': 2, 'B': 1}\n",
    "    sortedClassCount = sorted(classCount.items(), key=operator.itemgetter(1), reverse=True)\n",
    "    return sortedClassCount[0][0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0.1 0.1]\n",
      " [0.1 0.2]\n",
      " [1.1 1.2]\n",
      " [1.1 1.1]]\n",
      "[[0.01 0.01]\n",
      " [0.01 0.04]\n",
      " [1.21 1.44]\n",
      " [1.21 1.21]]\n",
      "distances: [0.14142136 0.2236068  1.62788206 1.55563492]\n",
      "sortedDistIndicies [0 1 3 2]\n",
      "{'A': 2, 'B': 1}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'A'"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "classify0([1.1,1.2], group, labels, 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'\\ndef classify0(inX,dataSet,labels,k):\\n    #求出样本集的行数，也就是labels标签的数目\\n    dataSetSize = dataSet.shape[0]\\n    #构造输入值和样本集的差值矩阵\\n    diffMat = tile(inX,(dataSetSize,1)) - dataSet\\n    #计算欧式距离\\n    sqDiffMat = diffMat**2\\n    sqDistances = sqDiffMat.sum(axis=1)\\n    distances = sqDistances**0.5\\n    #求距离从小到大排序的序号\\n    sortedDistIndicies = distances.argsort()\\n    #对距离最小的k个点统计对应的样本标签\\n    classCount = {}\\n    for i in range(k):\\n        #取第i+1近邻的样本对应的类别标签\\n        voteIlabel = labels[sortedDistIndicies[i]]\\n        #以标签为key，标签出现的次数为value将统计到的标签及出现次数写进字典\\n        classCount[voteIlabel] = classCount.get(voteIlabel,0) + 1\\n    #对字典按value从大到小排序\\n    sortedClassCount = sorted(classCount.items(),key=operator.itemgetter(1),reverse=True)\\n    #返回排序后字典中最大value对应的key\\n    return sortedClassCount[0][0]\\n#----------------------------------------------------------------------------\\n#函数运行耗时统计函数\\ndef time_me(fn):\\n  def _wrapper(*args, **kwargs):\\n    start = time.clock()\\n    fn(*args, **kwargs)\\n    print (\"\\n%s cost %s second\"%(fn.__name__, time.clock() - start))\\n  return _wrapper\\n'"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#网上的备注，我没有用到\n",
    "\"\"\"\n",
    "def classify0(inX,dataSet,labels,k):\n",
    "    #求出样本集的行数，也就是labels标签的数目\n",
    "    dataSetSize = dataSet.shape[0]\n",
    "    #构造输入值和样本集的差值矩阵\n",
    "    diffMat = tile(inX,(dataSetSize,1)) - dataSet\n",
    "    #计算欧式距离\n",
    "    sqDiffMat = diffMat**2\n",
    "    sqDistances = sqDiffMat.sum(axis=1)\n",
    "    distances = sqDistances**0.5\n",
    "    #求距离从小到大排序的序号\n",
    "    sortedDistIndicies = distances.argsort()\n",
    "    #对距离最小的k个点统计对应的样本标签\n",
    "    classCount = {}\n",
    "    for i in range(k):\n",
    "        #取第i+1近邻的样本对应的类别标签\n",
    "        voteIlabel = labels[sortedDistIndicies[i]]\n",
    "        #以标签为key，标签出现的次数为value将统计到的标签及出现次数写进字典\n",
    "        classCount[voteIlabel] = classCount.get(voteIlabel,0) + 1\n",
    "    #对字典按value从大到小排序\n",
    "    sortedClassCount = sorted(classCount.items(),key=operator.itemgetter(1),reverse=True)\n",
    "    #返回排序后字典中最大value对应的key\n",
    "    return sortedClassCount[0][0]\n",
    "#----------------------------------------------------------------------------\n",
    "#函数运行耗时统计函数\n",
    "def time_me(fn):\n",
    "  def _wrapper(*args, **kwargs):\n",
    "    start = time.clock()\n",
    "    fn(*args, **kwargs)\n",
    "    print (\"\\n%s cost %s second\"%(fn.__name__, time.clock() - start))\n",
    "  return _wrapper\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "#从文本文件中解析数据\n",
    "def file2matrix(filename):\n",
    "    love_dictionary={'largeDoses':3, 'smallDoses':2, 'didntLike':1}\n",
    "    fr = open(filename)\n",
    "    arrayOLines = fr.readlines()\n",
    "    #得到文件行数\n",
    "    numberOfLines = len(arrayOLines)            #get the number of lines in the file\n",
    "    returnMat = zeros((numberOfLines,3))        #prepare matrix to return\n",
    "    classLabelVector = []                       #prepare labels return   \n",
    "    index = 0\n",
    "    for line in arrayOLines:\n",
    "        #截取所有的回车字符\n",
    "        line = line.strip()\n",
    "        \"\"\"\n",
    "        split()通过指定分隔符对字符串进行切片，如果参数num 有指定值，则仅分隔 num 个子字符串\n",
    "        split()方法语法：\n",
    "            str.split(str=\"\",num=string.count(str))\n",
    "        参数\n",
    "            str -- 分隔符，默认为所有的空字符，包括空格、换行(\\n)、制表符(\\t)等。\n",
    "            num -- 分割次数。\n",
    "        \"\"\"\n",
    "        #将正行数据分割成元素列表\n",
    "        listFromLine = line.split('\\t')\n",
    "        #前三个元素存储到特征矩阵中\n",
    "        returnMat[index,:] = listFromLine[0:3]\n",
    "        #最后一列元素存储到向量中，元素值必须为整型，否则python会将这些元素当作字符串处理\n",
    "        if(listFromLine[-1].isdigit()):\n",
    "            classLabelVector.append(int(listFromLine[-1]))\n",
    "        else:\n",
    "            classLabelVector.append(love_dictionary.get(listFromLine[-1]))\n",
    "        index+=1\n",
    "    return returnMat,classLabelVector"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[4.0920000e+04, 8.3269760e+00, 9.5395200e-01],\n",
       "       [1.4488000e+04, 7.1534690e+00, 1.6739040e+00],\n",
       "       [2.6052000e+04, 1.4418710e+00, 8.0512400e-01],\n",
       "       ...,\n",
       "       [2.6575000e+04, 1.0650102e+01, 8.6662700e-01],\n",
       "       [4.8111000e+04, 9.1345280e+00, 7.2804500e-01],\n",
       "       [4.3757000e+04, 7.8826010e+00, 1.3324460e+00]])"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "datingDataMat,datinglabels=file2matrix('datingTestSet.txt')\n",
    "datingDataMat"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[3, 2, 1, 1, 1, 1, 3, 3, 1, 3, 1, 1, 2, 1, 1, 1, 1, 1, 2, 3]"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "datinglabels[:20]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.      , 0.      , 0.001156])"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "datingDataMat.min(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#自己创建的画图函数\n",
    "def zly_plot(datingDataMat,datinglabels):\n",
    "    import matplotlib\n",
    "    import matplotlib.pyplot as plt\n",
    "    fig=plt.figure()\n",
    "    ax=fig.add_subplot(111)\n",
    "    ax.scatter(datingDataMat[:,1],datingDataMat[:,2],15.0*array(datinglabels),15.0*array(datinglabels))\n",
    "    plt.show()\n",
    "zly_plot(datingDataMat,datinglabels)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "#归一化\n",
    "def autoNorm(dataSet):\n",
    "    #min(0)每列的最小值 \n",
    "    minVals = dataSet.min(0)\n",
    "    maxVals = dataSet.max(0)\n",
    "    ranges = maxVals - minVals\n",
    "    #此时 minVals maxVals为1*3矩阵\n",
    "    #normDataSet为1000*3的0矩阵\n",
    "    normDataSet = zeros(shape(dataSet))\n",
    "\n",
    "    #取出训练集的行数m\n",
    "    m = dataSet.shape[0]\n",
    "    normDataSet = dataSet - tile(minVals,(m,1))\n",
    "    #特征值相除   在numpy中矩阵除法：linalg.solve(matA,matB)\n",
    "    normDataSet = normDataSet/tile(ranges,(m,1))\n",
    "    #normDataSet：1000*3的百分比矩阵\n",
    "    #ranges：表示最大和最小的差值，1*3\n",
    "    #minVals：最小的值 1*3\n",
    "    return normDataSet,ranges,minVals\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([[0.44832535, 0.39805139, 0.56233353],\n",
       "        [0.15873259, 0.34195467, 0.98724416],\n",
       "        [0.28542943, 0.06892523, 0.47449629],\n",
       "        ...,\n",
       "        [0.29115949, 0.50910294, 0.51079493],\n",
       "        [0.52711097, 0.43665451, 0.4290048 ],\n",
       "        [0.47940793, 0.3768091 , 0.78571804]]),\n",
       " array([9.1273000e+04, 2.0919349e+01, 1.6943610e+00]),\n",
       " array([0.      , 0.      , 0.001156]))"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "autoNorm(datingDataMat)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [],
   "source": [
    "def datingClassTest():\n",
    "    hoRatio = 0.01\n",
    "    #读取数据\n",
    "    datingDataMat,datingLabels = file2matrix('datingTestSet2.txt')\n",
    "    #归一化\n",
    "    norMat, ranges, minVals = autoNorm(datingDataMat)\n",
    "    #m=1000，表示1000条数据\n",
    "    m = norMat.shape[0]\n",
    "    print(m)\n",
    "    #选择1000*0.1个测试数据\n",
    "    numTestVecs = int(m*hoRatio)\n",
    "    errorCount = 0.0\n",
    "    import random\n",
    "    for j in range(numTestVecs):\n",
    "        #得到分类器的值classify0\n",
    "        i=random.randint(0,999)\n",
    "        classifierResult = classify0(norMat[i,:],norMat[numTestVecs:m,:],datingLabels[numTestVecs:m],3)\n",
    "        print(\"分类器的分类结果:%d,真实的类别是:%d\"%(classifierResult,datingLabels[i]))\n",
    "        if classifierResult != datingLabels[i]:\n",
    "            errorCount += 1.0\n",
    "    print (\"错误率是%f\"%(errorCount/float(numTestVecs)))\n",
    "    print(errorCount)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1000\n",
      "分类器的分类结果:1,真实的类别是:1\n",
      "分类器的分类结果:2,真实的类别是:2\n",
      "分类器的分类结果:2,真实的类别是:2\n",
      "分类器的分类结果:3,真实的类别是:3\n",
      "分类器的分类结果:3,真实的类别是:3\n",
      "分类器的分类结果:1,真实的类别是:1\n",
      "分类器的分类结果:1,真实的类别是:1\n",
      "分类器的分类结果:3,真实的类别是:3\n",
      "分类器的分类结果:1,真实的类别是:1\n",
      "分类器的分类结果:2,真实的类别是:2\n",
      "错误率是0.000000\n",
      "0.0\n"
     ]
    }
   ],
   "source": [
    "datingClassTest()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "percentage of time spent playing video games?0\n",
      "frequent filer miles earned per year?60000\n",
      "liters of ice cream cosumed per year?0\n",
      "[    0. 60000.     0.]\n",
      "you will like the person: not at all\n"
     ]
    }
   ],
   "source": [
    "#实际输入的程序\n",
    "def classifyPerson():\n",
    "    resultList = ['not at all','in small doses','in large doses']\n",
    "    percentTats = float(input(\"percentage of time spent playing video games?\"))\n",
    "    ffMiles = float(input(\"frequent filer miles earned per year?\"))\n",
    "    iceCream = float(input(\"liters of ice cream cosumed per year?\"))\n",
    "    datingDataMat,datingLabels = file2matrix('datingTestSet.txt')\n",
    "    normMat, ranges, minVals = autoNorm(datingDataMat)\n",
    "    inArr = array([ffMiles, percentTats, iceCream])\n",
    "    print(inArr)\n",
    "    classifierResult = classify0((inArr-minVals)/ranges, normMat, datingLabels, 3)\n",
    "    print(\"you will like the person:\",resultList[classifierResult - 1])\n",
    "    \n",
    "classifyPerson()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "#手写数字识别\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "ename": "IndexError",
     "evalue": "list index out of range",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mIndexError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-4-aaf01412a830>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      7\u001b[0m             \u001b[0mreturnVect\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mi\u001b[0m\u001b[1;33m*\u001b[0m\u001b[1;36m32\u001b[0m\u001b[1;33m+\u001b[0m\u001b[0mj\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mlineStr\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mj\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      8\u001b[0m     \u001b[1;32mreturn\u001b[0m \u001b[0mreturnVect\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 9\u001b[1;33m \u001b[0mmat\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mimg2vector\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'testDigits/0_13.txt'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mshape\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;32m<ipython-input-4-aaf01412a830>\u001b[0m in \u001b[0;36mimg2vector\u001b[1;34m(filename)\u001b[0m\n\u001b[0;32m      5\u001b[0m         \u001b[0mlineStr\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mfr\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mreadlines\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      6\u001b[0m         \u001b[1;32mfor\u001b[0m \u001b[0mj\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m32\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 7\u001b[1;33m             \u001b[0mreturnVect\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mi\u001b[0m\u001b[1;33m*\u001b[0m\u001b[1;36m32\u001b[0m\u001b[1;33m+\u001b[0m\u001b[0mj\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mlineStr\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mj\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      8\u001b[0m     \u001b[1;32mreturn\u001b[0m \u001b[0mreturnVect\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      9\u001b[0m \u001b[0mmat\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mimg2vector\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'testDigits/0_13.txt'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mshape\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mIndexError\u001b[0m: list index out of range"
     ]
    }
   ],
   "source": [
    "def img2vector(filename):\n",
    "    returnVect = zeros((1,1024))\n",
    "    fr = open(filename)\n",
    "    for i in range(32):\n",
    "        lineStr = fr.readline()\n",
    "        for j in range(32):\n",
    "            returnVect[0,i*32+j] = int(lineStr[j])\n",
    "    return returnVect\n",
    "mat(img2vector('testDigits/0_13.txt')).shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['0_0.txt',\n",
       " '0_1.txt',\n",
       " '0_10.txt',\n",
       " '0_100.txt',\n",
       " '0_101.txt',\n",
       " '0_102.txt',\n",
       " '0_103.txt',\n",
       " '0_104.txt',\n",
       " '0_105.txt',\n",
       " '0_106.txt']"
      ]
     },
     "execution_count": 123,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "trainingFileList = listdir('trainingDigits')\n",
    "trainingFileList[0:10]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "QQQQ 1934\n",
      "0这个数字分类的结果是0\n",
      "总共错误的个数：0\n",
      "错误率是：0.000000\n"
     ]
    }
   ],
   "source": [
    "def handwritingClassTest():\n",
    "    #初始化类别标签为空列表\n",
    "    hwLabels = []\n",
    "    #得到目录trainingDigits下的所有文件名\n",
    "    trainingFileList = listdir('trainingDigits')\n",
    "    #m=1934，表示1934个训练文件数，每个文件是32*32，后面经过处理后：1*1024\n",
    "    m = len(trainingFileList)\n",
    "    #生成1934*1024的0矩阵\n",
    "    trainingMat = zeros((m,1024))\n",
    "    for i in range(m):\n",
    "        #fileNameStr表示'0_0.txt'\n",
    "        fileNameStr = trainingFileList[i]\n",
    "        #print(fileNameStr)\n",
    "        #fileStr表示0_0\n",
    "        fileStr = fileNameStr.split('.')[0]\n",
    "        #print(fileStr)\n",
    "        #a表示这个图片属于哪个分类，该例子中：0\n",
    "        a = fileStr.split('_')[0]\n",
    "        #print(a)\n",
    "        classNumStr = int(a)\n",
    "        #将代表该训练数据类别的数字存入类别标签列表\n",
    "        hwLabels.append(classNumStr)\n",
    "        #将原本32*32的数组转为1*1024的数组，放入trainingMat\n",
    "        trainingMat[i,:] = img2vector('trainingDigits/%s'%fileNameStr)\n",
    "    #得到目录testDigits下的所有文件名\n",
    "    testFileList = listdir('testDigits')\n",
    "    #初始化错误样本的个数\n",
    "    errorCount = 0.0\n",
    "    #得到测试样本的个数\n",
    "    mTest = len(testFileList)\n",
    "    #为了加快速度，我设置mTest为1\n",
    "    mTest=1\n",
    "    for i in range(mTest):\n",
    "        #得到一个测试的文件名\n",
    "        fileNameStr0 = testFileList[i]\n",
    "        #去掉.txt\n",
    "        fileStr0 = fileNameStr0.split('.')[0]\n",
    "        #得到该测试文件的类别\n",
    "        classNumStr0 = int(fileStr0.split('_')[0])\n",
    "        #将原本32*32的数组转为1*1024的数组\n",
    "        vectorUnderTest = img2vector('trainingDigits/%s'%fileNameStr0)\n",
    "        classifierResult = classify0(vectorUnderTest,trainingMat,hwLabels,3)\n",
    "        print('%d这个数字分类的结果是%d'%(classNumStr0,classifierResult))\n",
    "        if classifierResult != classNumStr0:\n",
    "            errorCount += 1\n",
    "    print('总共错误的个数：%d'%errorCount)\n",
    "    print('错误率是：%f'%((errorCount/float(mTest))))\n",
    "handwritingClassTest()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#---------------------------------------------------------------------------- \n",
    "#手写数字识别测试函数\n",
    "def handwritingClassTest(): \n",
    "    #初始化类别标签为空列表\n",
    "    hwLabels = []\n",
    " \n",
    "    #列出给定目录下所有训练数据的文件名\n",
    "    trainingFileList = listdir('F:/machinelearninginaction/Ch02/trainingDigits')\n",
    " \n",
    "    #求训练数据数目\n",
    "    m = len(trainingFileList)\n",
    " \n",
    "    #初始化m个图像的训练矩阵\n",
    "    trainingMat = zeros((m,1024))\n",
    "    \n",
    "    #遍历每一个训练数据\n",
    "    for i in range(m):\n",
    " \n",
    "        #取出一个训练数据的文件名\n",
    "        fileNameStr = trainingFileList[i]\n",
    " \n",
    "        #去掉该训练数据的后缀名.txt\n",
    "        fileStr = fileNameStr.split('.')[0]\n",
    " \n",
    "        #取出代表该训练数据类别的数字\n",
    "        classNumStr = int(fileStr.split('_')[0])\n",
    " \n",
    "        #将代表该训练数据类别的数字存入类别标签列表\n",
    "        hwLabels.append(classNumStr)\n",
    " \n",
    "        #调用图像转换函数将该训练数据的输入特征转换为向量并存储\n",
    "        trainingMat[i,:] = img2vector('F:/machinelearninginaction/Ch02/trainingDigits/%s' % fileNameStr)\n",
    " \n",
    "    #列出给定目录下所有测试数据的文件名\n",
    "    testFileList = listdir('F:/machinelearninginaction/Ch02/testDigits')\n",
    " \n",
    "    #初始化测试犯错的样本个数\n",
    "    errorCount = 0.0\n",
    " \n",
    "    #求测试数据数目\n",
    "    mTest = len(testFileList)\n",
    " \n",
    "    #遍历每一个测试数据\n",
    "    for i in range(mTest):\n",
    " \n",
    "        #取出一个测试数据的文件名\n",
    "        fileNameStr = testFileList[i]\n",
    " \n",
    "        #去掉该测试数据的后缀名.txt\n",
    "        fileStr = fileNameStr.split('.')[0]\n",
    " \n",
    "        #取出代表该测试数据类别的数字\n",
    "        classNumStr = int(fileStr.split('_')[0])\n",
    " \n",
    "        #调用图像转换函数将该测试数据的输入特征转换为向量\n",
    "        vectorUnderTest = img2vector('F:/machinelearninginaction/Ch02/testDigits/%s' % fileNameStr)\n",
    " \n",
    "        #调用k-NN简单实现函数，并返回分类器对该测试数据的分类结果\n",
    "        classifierResult = classify0(vectorUnderTest,trainingMat,hwLabels,3)\n",
    " \n",
    "        print(\"the classifier came back with: %d, the real answer is: %d\" % (classifierResult,classNumStr))\n",
    " \n",
    "        #统计分类器对测试数据分类犯错的个数\n",
    "        if (classifierResult != classNumStr):\n",
    "              errorCount += 1.0\n",
    "    print(\"\\nthe total number of error is: %d\" % errorCount)\n",
    " \n",
    "    #输出分类器错误率\n",
    "    print(\"\\nthe total error rate is: %f\" % (errorCount/float(mTest)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#婚恋代码详细解释\n",
    "from numpy import *\n",
    "import operator\n",
    " \n",
    "#样本数据集创建函数\n",
    "def creatDataSet():\n",
    "    dataSet = array([[1.0,1.1],[1.0,1.0],[0,0],[0,0.1]])\n",
    "    labels = ['A','A','B','B']\n",
    "    return dataSet,labels\n",
    " \n",
    " \n",
    "#k-NN简单实现函数\n",
    "def classify0(inX,dataSet,labels,k):\n",
    " \n",
    "    #求出样本集的行数，也就是labels标签的数目\n",
    "    dataSetSize = dataSet.shape[0]\n",
    " \n",
    "    #构造输入值和样本集的差值矩阵\n",
    "    diffMat = tile(inX,(dataSetSize,1)) - dataSet\n",
    " \n",
    "    #计算欧式距离\n",
    "    sqDiffMat = diffMat**2\n",
    "    sqDistances = sqDiffMat.sum(axis=1)\n",
    "    distances = sqDistances**0.5\n",
    " \n",
    "    #求距离从小到大排序的序号\n",
    "    sortedDistIndicies = distances.argsort()\n",
    " \n",
    "    #对距离最小的k个点统计对应的样本标签\n",
    "    classCount = {}\n",
    "    for i in range(k):\n",
    "        #取第i+1近邻的样本对应的类别标签\n",
    "        voteIlabel = labels[sortedDistIndicies[i]]\n",
    "        #以标签为key，标签出现的次数为value将统计到的标签及出现次数写进字典\n",
    "        classCount[voteIlabel] = classCount.get(voteIlabel,0) + 1\n",
    " \n",
    "    #对字典按value从大到小排序\n",
    "    sortedClassCount = sorted(classCount.items(),key=operator.itemgetter(1),reverse=True)\n",
    " \n",
    "    #返回排序后字典中最大value对应的key\n",
    "    return sortedClassCount[0][0]\n",
    " \n",
    "#从文本文件中解析数据\n",
    "def file2matrix(filename):\n",
    "    fr = open(filename)\n",
    "    \n",
    "    #按行读取整个文件的内容\n",
    "    arrayOfLines = fr.readlines()\n",
    "    \n",
    "    #求文件行数，即样本总数\n",
    "    numberOfLines = len(arrayOfLines)\n",
    " \n",
    "    #初始化返回数组及列表\n",
    "    returnMat = zeros((numberOfLines,3))\n",
    "    classLabelVector = []\n",
    "    \n",
    "    index = 0\n",
    "    for line in arrayOfLines:\n",
    "        #截取掉每一行的回车符\n",
    "        line = line.strip()\n",
    "        #将一行数据根据制表符分割成包含多个元素（特征）的列表\n",
    "        listFromLine = line.split('\\t')\n",
    "        #分割后的特征数据列表存入待返回的numpy数组\n",
    "        returnMat[index,:] = listFromLine[0:3]\n",
    "        #将文件每一行最后一列的数据存入待返回的分类标签列表\n",
    "        classLabelVector.append(int(listFromLine[-1]))\n",
    "        #控制待返回的numpy数组进入下一行\n",
    "        index+=1\n",
    "    return returnMat,classLabelVector\n",
    " \n",
    "#特征变量归一化\n",
    "def autoNorm(dataSet):\n",
    " \n",
    "    #取出每一列的最小值，即每一个特征的最小值\n",
    "    minVals = dataSet.min(0)\n",
    " \n",
    "    #取出每一列的最大值，即每一个特征的最大值\n",
    "    maxVals = dataSet.max(0)\n",
    " \n",
    "    #每一个特征变量的变化范围\n",
    "    ranges = maxVals - minVals\n",
    " \n",
    "    #初始化待返回的归一化特征数据集\n",
    "    normDataSet = zeros(shape(dataSet))\n",
    " \n",
    "    #特征数据集行数，即样本个数\n",
    "    m = dataSet.shape[0]\n",
    " \n",
    "    #利用tile()函数构造与原特征数据集同大小的矩阵，并进行归一化计算\n",
    "    normDataSet = dataSet - tile(minVals,(m,1))\n",
    "    normDataSet = normDataSet/tile(ranges,(m,1))\n",
    " \n",
    "    return normDataSet,ranges,minVals\n",
    " \n",
    "#分类器测试\n",
    "def datingClassTest():\n",
    " \n",
    "    #给定用于测试分类器的样本比例\n",
    "    hoRatio = 0.10\n",
    " \n",
    "    #调用文本数据解析函数\n",
    "    datingDataMat,datingLabels = file2matrix('F:/programming tools/datingTestSet2.txt')\n",
    " \n",
    "    #调用特征变量归一化函数\n",
    "    normMat,ranges,minVals = autoNorm(datingDataMat)\n",
    " \n",
    "    #归一化的特征数据集行数，即样本个数\n",
    "    m = normMat.shape[0]\n",
    " \n",
    "    #用于测试分类器的测试样本个数\n",
    "    numTestVecs = int(m*hoRatio)\n",
    "    \n",
    "    #初始化分类器犯错样本个数\n",
    "    errorCount = 0.0\n",
    "    \n",
    "    for i in range(numTestVecs):\n",
    "        #以测试样本作为输入，测试样本之后的样本作为训练样本，对测试样本进行分类\n",
    "        classifierResult = classify0(normMat[i,:],normMat[numTestVecs:m,:],datingLabels[numTestVecs:m],3)\n",
    " \n",
    "        #对比分类器对测试样本预测的类别和其真实类别\n",
    "        print(\"the classifier came back with: %d,the real answer is: %d\" % (classifierResult,datingLabels[i]))\n",
    " \n",
    "        #统计分类出错的测试样本数\n",
    "        if (classifierResult != datingLabels[i]):\n",
    "            errorCount+=1.0\n",
    " \n",
    "    #输出分类器错误率        \n",
    "    print(\"the total error rate is: %f\" % (errorCount/float(numTestVecs)))\n",
    " \n",
    "#约会网站对新输入分类\n",
    "def classifyPerson():\n",
    " \n",
    "    #定义一个存储了三个字符串的列表，分别对应不喜欢，一般喜欢，很喜欢\n",
    "    resultList = ['not at all','in small dose','in large dose']\n",
    " \n",
    "    #用户输入三个特征变量，并将输入的字符串类型转化为浮点型\n",
    "    ffMiles = float(input(\"frequent flier miles earned per year:\"))\n",
    "    percentats = float(input(\"percentage of time spent playing video games:\"))\n",
    "    iceCream = float(input(\"liters of ice cream consumed per year:\"))\n",
    " \n",
    "    #调用文本数据解析函数\n",
    "    datingDataMat,datingLabels = file2matrix('F:\\programming tools\\datingTestSet2.txt')\n",
    " \n",
    "    #调用特征变量归一化函数\n",
    "    normMat,ranges,minVals = autoNorm(datingDataMat)\n",
    " \n",
    "    #将输入的特征变量构造成特征数组（矩阵）形式\n",
    "    inArr = array([ffMiles,percentats,iceCream])\n",
    "    #调用kNN简单实现函数\n",
    "    classifierResult = classify0((inArr-minVals)/ranges,normMat,datingLabels,3)\n",
    "    #将分类结果由数字转换为字符串\n",
    "    print(\"You will probably like this person\",resultList[classifierResult - 1])"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
